using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("DeckTrayCardListContent")]
	public class DeckTrayCardListContent : DeckTrayContent
	{
		public float m_cardTileHeight => method_2<float>("m_cardTileHeight");

		public float m_cardHelpButtonHeight => method_2<float>("m_cardHelpButtonHeight");

		public float m_deckCardBarFlareUpInterval => method_2<float>("m_deckCardBarFlareUpInterval");

		public GameObject m_phoneDeckTileBone => method_3<GameObject>("m_phoneDeckTileBone");

		public Vector3 m_cardTileOffset => method_2<Vector3>("m_cardTileOffset");

		public float m_cardTileSlotLocalHeight => method_2<float>("m_cardTileSlotLocalHeight");

		public Vector3 m_cardTileSlotLocalScaleVec3 => method_2<Vector3>("m_cardTileSlotLocalScaleVec3");

		public UIBButton m_deckHelpButton => method_3<UIBButton>("m_deckHelpButton");

		public UIBButton m_deckTemplateHelpButton => method_3<UIBButton>("m_deckTemplateHelpButton");

		public GameObject m_deckCompleteHighlight => method_3<GameObject>("m_deckCompleteHighlight");

		public UIBScrollable m_scrollbar => method_3<UIBScrollable>("m_scrollbar");

		public BoxCollider m_LockedScrollBounds => method_3<BoxCollider>("m_LockedScrollBounds");

		public CollectionManager.DeckTag m_deckType => method_2<CollectionManager.DeckTag>("m_deckType");

		public static string ADD_CARD_TO_DECK_SOUND => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "DeckTrayCardListContent", "ADD_CARD_TO_DECK_SOUND");

		public static float CARD_MOVEMENT_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayCardListContent", "CARD_MOVEMENT_TIME");

		public Vector3 m_originalLocalPosition => method_2<Vector3>("m_originalLocalPosition");

		public List<DeckTrayDeckTileVisual> m_cardTiles => method_3<Class271<DeckTrayDeckTileVisual>>("m_cardTiles")?.method_25();

		public bool m_animating => method_2<bool>("m_animating");

		public bool m_loading => method_2<bool>("m_loading");

		public static float DECK_HELP_BUTTON_EMPTY_DECK_Y_LOCAL_POS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayCardListContent", "DECK_HELP_BUTTON_EMPTY_DECK_Y_LOCAL_POS");

		public static float DECK_HELP_BUTTON_Y_TILE_OFFSET => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayCardListContent", "DECK_HELP_BUTTON_Y_TILE_OFFSET");

		public bool m_inArena => method_2<bool>("m_inArena");

		public CollectionDeck m_templateFakeDeck => method_3<CollectionDeck>("m_templateFakeDeck");

		public bool m_isShowingFakeDeck => method_2<bool>("m_isShowingFakeDeck");

		public bool m_hasFinishedEntering => method_2<bool>("m_hasFinishedEntering");

		public bool m_hasFinishedExiting => method_2<bool>("m_hasFinishedExiting");

		public Notification m_deckHelpPopup => method_3<Notification>("m_deckHelpPopup");

		public DeckTrayCardListContent(IntPtr address, string className)
			: base(address, className)
		{
		}

		public DeckTrayCardListContent(IntPtr address)
			: this(address, "DeckTrayCardListContent")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public new bool AnimateContentEntranceStart()
		{
			return method_11<bool>("AnimateContentEntranceStart", Array.Empty<object>());
		}

		public new bool AnimateContentEntranceEnd()
		{
			return method_11<bool>("AnimateContentEntranceEnd", Array.Empty<object>());
		}

		public new bool AnimateContentExitStart()
		{
			return method_11<bool>("AnimateContentExitStart", Array.Empty<object>());
		}

		public new bool AnimateContentExitEnd()
		{
			return method_11<bool>("AnimateContentExitEnd", Array.Empty<object>());
		}

		public bool HasFinishedEntering()
		{
			return method_11<bool>("HasFinishedEntering", Array.Empty<object>());
		}

		public bool HasFinishedExiting()
		{
			return method_11<bool>("HasFinishedExiting", Array.Empty<object>());
		}

		public new void OnTaggedDeckChanged(CollectionManager.DeckTag tag, CollectionDeck newDeck, CollectionDeck oldDeck, bool isNewDeck)
		{
			method_8("OnTaggedDeckChanged", tag, newDeck, oldDeck, isNewDeck);
		}

		public void ShowDeckHelper(DeckTrayDeckTileVisual tileToRemove, bool continueAfterReplace, bool replacingCard)
		{
			method_8("ShowDeckHelper", tileToRemove, continueAfterReplace, replacingCard);
		}

		public Vector3 GetCardVisualExtents()
		{
			return method_11<Vector3>("GetCardVisualExtents", Array.Empty<object>());
		}

		public List<DeckTrayDeckTileVisual> GetCardTiles()
		{
			return method_14<Class271<DeckTrayDeckTileVisual>>("GetCardTiles", Array.Empty<object>())?.method_25();
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(string cardID)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[1] { Class276.Enum20.String }, new object[1] { cardID });
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(string cardID, TAG_PREMIUM premType)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, new object[2] { cardID, premType });
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(int index)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { index });
		}

		public DeckTrayDeckTileVisual GetCardTileVisualOrLastVisible(string cardID)
		{
			return method_14<DeckTrayDeckTileVisual>("GetCardTileVisualOrLastVisible", new object[1] { cardID });
		}

		public DeckTrayDeckTileVisual GetOrAddCardTileVisual(int index)
		{
			return method_14<DeckTrayDeckTileVisual>("GetOrAddCardTileVisual", new object[1] { index });
		}

		public void UpdateTileVisuals()
		{
			method_8("UpdateTileVisuals");
		}

		public new void Show(bool showAll)
		{
			method_8("Show", showAll);
		}

		public new void Hide(bool hideAll)
		{
			method_8("Hide", hideAll);
		}

		public void CommitFakeDeckChanges()
		{
			method_8("CommitFakeDeckChanges");
		}

		public CollectionDeck GetEditingDeck()
		{
			return method_14<CollectionDeck>("GetEditingDeck", Array.Empty<object>());
		}

		public void ShowFakeDeck(bool show)
		{
			method_8("ShowFakeDeck", show);
		}

		public void ResetFakeDeck()
		{
			method_8("ResetFakeDeck");
		}

		public void ShowDeckCompleteEffects()
		{
			method_8("ShowDeckCompleteEffects");
		}

		public void SetInArena(bool inArena)
		{
			method_8("SetInArena", inArena);
		}

		public bool AddCard(EntityDef cardEntityDef, TAG_PREMIUM premium, DeckTrayDeckTileVisual deckTileToRemove, bool playSound, Actor animateFromActor, bool allowInvalid)
		{
			return method_11<bool>("AddCard", new object[6] { cardEntityDef, premium, deckTileToRemove, playSound, animateFromActor, allowInvalid });
		}

		public int RemoveClosestInvalidCard(EntityDef entityDef, int sameRemoveCount)
		{
			return method_11<int>("RemoveClosestInvalidCard", new object[2] { entityDef, sameRemoveCount });
		}

		public void UpdateCardList(bool updateHighlight, Actor animateFromActor)
		{
			method_9("UpdateCardList", new Class276.Enum20[2]
			{
				Class276.Enum20.Boolean,
				Class276.Enum20.Class
			}, updateHighlight, animateFromActor);
		}

		public void UpdateCardList(EntityDef justChangedCardEntityDef, bool updateHighlight, Actor animateFromActor)
		{
			method_9("UpdateCardList", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Class
			}, justChangedCardEntityDef, updateHighlight, animateFromActor);
		}

		public void UpdateCardList(string justChangedCardID, bool updateHighlight, Actor animateFromActor)
		{
			method_9("UpdateCardList", new Class276.Enum20[3]
			{
				Class276.Enum20.String,
				Class276.Enum20.Boolean,
				Class276.Enum20.Class
			}, justChangedCardID, updateHighlight, animateFromActor);
		}

		public Vector3 GetCardTileOffset(CollectionDeck currentDeck)
		{
			return method_11<Vector3>("GetCardTileOffset", new object[1] { currentDeck });
		}

		public void TriggerCardCountUpdate()
		{
			method_8("TriggerCardCountUpdate");
		}

		public void HideDeckHelpPopup()
		{
			method_8("HideDeckHelpPopup");
		}

		public DeckTrayDeckTileVisual GetFirstInvalidCard()
		{
			return method_14<DeckTrayDeckTileVisual>("GetFirstInvalidCard", Array.Empty<object>());
		}

		public void UpdateDeckCompleteHighlight()
		{
			method_8("UpdateDeckCompleteHighlight");
		}

		public Notification GetDeckHelpPopup()
		{
			return method_14<Notification>("GetDeckHelpPopup", Array.Empty<object>());
		}

		public void IsCardTileVisible(GameObject obj, bool visible)
		{
			method_8("IsCardTileVisible", obj, visible);
		}

		public void ShowDeckEditingTipsIfNeeded()
		{
			method_8("ShowDeckEditingTipsIfNeeded");
		}

		public void ShowDeckHelpButtonIfNeeded()
		{
			method_8("ShowDeckHelpButtonIfNeeded");
		}

		public void OnDeckHelpButtonPress(UIEvent e)
		{
			method_8("OnDeckHelpButtonPress", e);
		}

		public void OnDeckTemplateHelpButtonPress(UIEvent e)
		{
			method_8("OnDeckTemplateHelpButtonPress", e);
		}

		public void OnDeckHelpButtonOver(UIEvent e)
		{
			method_8("OnDeckHelpButtonOver", e);
		}

		public void OnDeckHelpButtonOut(UIEvent e)
		{
			method_8("OnDeckHelpButtonOut", e);
		}

		public void OnDeckTemplateHelpButtonOver(UIEvent e)
		{
			method_8("OnDeckTemplateHelpButtonOver", e);
		}

		public void OnDeckTemplateHelpButtonOut(UIEvent e)
		{
			method_8("OnDeckTemplateHelpButtonOut", e);
		}

		public Vector3 GetOffscreenLocalPosition()
		{
			return method_11<Vector3>("GetOffscreenLocalPosition", Array.Empty<object>());
		}

		public void FireCardTileHeldEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileHeldEvent", cardTile);
		}

		public void FireCardTilePressEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTilePressEvent", cardTile);
		}

		public void FireCardTileTapEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileTapEvent", cardTile);
		}

		public void FireCardTileOverEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileOverEvent", cardTile);
		}

		public void FireCardTileOutEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileOutEvent", cardTile);
		}

		public void FireCardTileReleaseEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileReleaseEvent", cardTile);
		}

		public void FireCardTileRightClickedEvent(DeckTrayDeckTileVisual cardTile)
		{
			method_8("FireCardTileRightClickedEvent", cardTile);
		}

		public void FireCardCountChangedEvent()
		{
			method_8("FireCardCountChangedEvent");
		}
	}
}
